public class Array02 {

        public static void func1(int[] array){
            array = new int[10];
        }
        public static void func2(int[] array) {
            array[0] = 99;
        }
        public static int[] func3(){
            int[] array = {1,2,3,4,5,6};
            return array;
            //可简写为
            //return new int[]{1,2,3,4,5,6};
        }
        public static int binarySearch(int[] arr,int toFind) {
            int left = 0;
            int right = arr.length - 1;
            while (left <= right) {
                int mid = (left + right) / 2;
                if (toFind < arr[mid]) {
                    right = mid - 1;
                } else if (toFind > arr[mid]) {
                    left = mid + 1;
                } else {
                    return mid;
                }
            }
            return -1;

        }

        public static void main(String[] args) {
            int[] array1 = {1,2,3,4};
            func1(array1);

            for (int i = 0;i < array1.length;i++) {
                System.out.println(array1[i] + "");
            }

            int[] array2 = {1,2,3,4};
            func2(array2);


            for (int i = 0;i < array2.length;i++) {
                System.out.println(array2[i] + "");
            }

            int[] ret = func3();
            for (int i = 0; i < ret.length;i++) {
                System.out.println(ret[i] + " ");
            }

            int[] arr = {1,2,3,4,5,6};
            System.out.println(binarySearch(arr, 6));

            /*
            * Java数组知识点总结
一、数组的基本概念
定义：数组是存储相同数据类型元素的有序集合，通过索引访问元素，索引从0开始。

特点：

长度固定，创建后无法动态扩展。

内存连续分配，访问高效。

所有元素类型相同（可以是基本类型或对象类型）。

二、数组的声明与初始化
1. 声明方式
java
复制
// 方式1：推荐
数据类型[] 数组名;   // 如 int[] arr;

// 方式2：兼容C语言风格（不推荐）
数据类型 数组名[];   // 如 int arr[];
2. 初始化方式
静态初始化：声明时直接赋值。

java
复制
int[] arr1 = {1, 2, 3};               // 一维数组
String[] names = {"Alice", "Bob"};
int[][] matrix = {{1,2}, {3,4}};      // 二维数组
动态初始化：声明后分配空间，再赋值。

java
复制
int[] arr2 = new int[3];             // 默认值为0
arr2[0] = 10;                        // 手动赋值
double[] scores = new double[5];

// 二维数组动态初始化
int[][] matrix = new int[2][3];       // 2行3列
matrix[0][1] = 5;                    // 赋值
三、数组的访问与遍历
1. 访问元素
java
复制
int[] arr = {10, 20, 30};
System.out.println(arr[0]);    // 输出10（索引从0开始）
arr[1] = 50;                   // 修改第二个元素为50
2. 遍历数组
普通for循环：

java
复制
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}
增强for循环（foreach）：

java
复制
for (int num : arr) {
    System.out.println(num);
}
3. 注意事项
数组越界：访问索引超出范围时抛出ArrayIndexOutOfBoundsException。

java
复制
int[] arr = new int[3];
System.out.println(arr[3]); // 错误！最大索引为2
四、多维数组
1. 二维数组定义
动态初始化：

java
复制
int[][] matrix = new int[2][3];  // 2行3列
matrix[0][1] = 5;               // 第0行第1列赋值
静态初始化：

java
复制
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6}
};
2. 遍历二维数组
java
复制
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.print(matrix[i][j] + " ");
    }
    System.out.println();
}
3. 不规则数组
允许每行长度不同：

java
复制
int[][] jagged = new int[3][];
jagged[0] = new int[2];
jagged[1] = new int[3];
jagged[2] = new int[4];
五、数组的常用操作
1. 工具类Arrays
排序：Arrays.sort(arr)

java
复制
int[] arr = {3, 1, 4};
Arrays.sort(arr);      // 排序后arr变为[1, 3, 4]
二分查找：Arrays.binarySearch(arr, key)

java
复制
int index = Arrays.binarySearch(arr, 3); // 返回1（需数组已排序）
复制数组：Arrays.copyOf()

java
复制
int[] newArr = Arrays.copyOf(arr, 5); // 新数组长度为5，多余元素补默认值
填充数组：Arrays.fill(arr, value)

java
复制
Arrays.fill(arr, 0);   // 所有元素置为0
转换为字符串：Arrays.toString(arr)

java
复制
System.out.println(Arrays.toString(arr)); // 输出格式如[1, 3, 4]
2. 数组长度
通过数组名.length获取长度（属性，非方法）。

java
复制
int len = arr.length; // 一维数组长度
int rows = matrix.length;    // 二维数组行数
int cols = matrix[0].length; // 二维数组列数（需确保行存在）
六、数组的注意事项
默认值规则：

基本类型数组：int为0，double为0.0，boolean为false。

引用类型数组：初始值为null。

数组是对象：

数组继承自Object类，可调用Object的方法（如toString()）。

直接打印数组会输出哈希码，需用Arrays.toString()格式化输出。

作为方法参数：

数组是引用类型，方法内修改会影响原数组。

java
复制
public static void modifyArray(int[] arr) {
    arr[0] = 100;
}
// 调用后原数组的第一个元素被修改
性能与限制：

适合元素数量固定且频繁访问的场景。

动态扩展需手动创建新数组并复制元素（或使用ArrayList）。

七、数组 vs. ArrayList
特性	数组	ArrayList
长度	固定	动态扩展
元素类型	必须相同	支持泛型（类型安全）
性能	访问快（连续内存）	插入/删除可能较慢（需移动元素）
方法支持	需借助Arrays工具类	内置增删改查方法
内存开销	低（仅存储数据）	略高（维护容量和动态调整）
适用场景	元素数量固定、高频访问	元素数量变化频繁
八、代码示例
1. 数组反转
java
复制
public static void reverseArray(int[] arr) {
    for (int i = 0; i < arr.length / 2; i++) {
        int temp = arr[i];
        arr[i] = arr[arr.length - 1 - i];
        arr[arr.length - 1 - i] = temp;
    }
}
2. 查找最大值
java
复制
public static int findMax(int[] arr) {
    int max = arr[0];
    for (int num : arr) {
        if (num > max) {
            max = num;
        }
    }
    return max;
}
九、常见问题
数组越界如何避免？

始终确保索引在0到length-1之间。

如何动态扩展数组？

创建新数组并复制元素：

java
复制
int[] newArr = Arrays.copyOf(arr, arr.length * 2);
多维数组的内存结构？

二维数组是“数组的数组”，每行可独立分配内存（如不规则数组）。

总结
核心用途：高效存储和访问固定数量的同类型数据。

关键操作：声明、初始化、遍历、工具类方法。

注意事项：长度不可变、默认值、引用传递特性。

适用场景：优先选择数组处理固定大小的数据，动态需求时使用集合类。*/


        }


    }


